import isEmpty from 'loadsh/isEmpty'
import compact from 'loadsh/compact'
import {
  GetOrderManagementInfo,
  PostDeleteData,
  PostOrderManagementInfo
} from '/constData/requestFun/_httpRequest';
import {
  GetOrder,
  GetOrderById,
  GetOrderManagement,
  GetOrderManagementById,
  GetReturnDocx,
  GetUserInfo,
  OrderDeleteData,
  OrderManagementDeleteData,
  PostOrder,
  PostOrderAddItem,
  PostOrderManagement,
  PutOrderById
} from '/constData/requestFun/_teseRequest';
import {
  GetUserInfoFiled
} from '/constData/requestFun/_utils';
Page({
  data: {
    item: 1,
    min: null,
    max: new Date('2033/12/02'),
    defaultDate: '',
    defaultValue: '设备A',
    list: ['设备A', '设备B', '设备C', '设备D'],
    OrderInfo: {
      CorpId: '', //申请人
      Numbering: '', //编号
      WorkNumber: '', //随工单号
      CustomerName: '', //客户名称
      CommissionEngineers: '', //委托工程师
      ContactNumber: '', //联系电话
      ProductsNumber: '', //产品数量
      ProductsName: '', //产品名称
      ProductsModel: '', //产品型号
      ProductsLots: '', //产品批次
      FormFactor: '', //封装形式
      Scene: '是', //现场
      Urgency: '正常', //紧急程度
      CompletionTime: new Date(), //完成时间
      EstimatedTime: new Date(),//预计最终完成时间
      Temperature: '', //温度
      Humidity: '', //湿度
      Items: [{
        EstimatedTime: new Date(),//预计完成时间
        ReasonExtension: '',//延期原因
        FinalTime: new Date(),//最终完成时间
        TestResult: '',//检测结果
        SampleNumber: '',//样品编号
        Project: '',//检测项目
        Condition: '',//检测条件
        Engineer: '',//检测人员
        DisEngineer: '',//检测用时
        Quantity: '',//检测数量
        DeviceNumber: '',//设备编号
        StartTime: new Date(),//开始时间
        EndTime: new Date(),//结束时间
        TrialTime: '',//检测用时
        Sign: '',//复核签字
        ScoringFactor: '',//评分因子
        ExtensionDate: '',//延期日期
      }], //试验
      Laboratory: '是', //是否留着实验室
      Fabricated: '', //拟制
      Review: '', //复核
      ProposedDate: new Date(),
      ReviewDate: new Date(),
      Code: [], //样品编号
    },
    AddOrderItem: {
      id: '',
      EstimatedTime: new Date(),//预计完成时间
      ReasonExtension: '',//延期原因
      FinalTime: new Date(),//最终完成时间
      TestResult: '',//检测结果
      SampleNumber: '',//样品编号
      Project: '',//检测项目
      Condition: '',//检测条件
      Engineer: '',//检测人员
      DisEngineer: '',//检测用时
      Quantity: '',//检测数量
      DeviceNumber: '',//设备编号
      StartTime: new Date(),//开始时间
      EndTime: new Date(),//结束时间
      TrialTime: '',//检测用时
      Sign: '',//复核签字
      ExtensionDate: '',//延期日期
      ScoringFactor: '',
      CreateTime: "2024-06-07T07:07:14.612Z",
      OrderId: 0,
      VirtualStartTime: '',
      VirtualEndTime: '',
      VirtualTrialTime: '',
      TotalTime: 0,
    },
    ModifyOrderItem: {
      id: '',
      OrderId: '',
      EstimatedTime: new Date(),//预计完成时间
      ReasonExtension: '',//延期原因
      FinalTime: new Date(),//最终完成时间
      TestResult: '',//检测结果
      SampleNumber: '',//样品编号
      Project: '',//检测项目
      Condition: '',//检测条件
      Engineer: '',//检测人员
      DisEngineer: '',//检测用时
      Quantity: '',//检测数量
      DeviceNumber: '',//设备编号
      StartTime: new Date(),//开始时间
      EndTime: new Date(),//结束时间
      TrialTime: '',//检测用时
      Sign: '',//复核签字
      ExtensionDate: '',//延期日期
    },
    options: [{
      value: '是',
      label: '是'
    },
    {
      value: '否',
      label: '否'
    },
    ],
    options1: [{
      value: '正常',
      label: '正常'
    },
    {
      value: '紧急',
      label: '紧急'
    },
    ],
    options2: [{
      value: '是',
      label: '是'
    },
    {
      value: '否',
      label: '否'
    },
    ],
    ReceiveData: [],
    FinshData: [],
    position: '',
    animation: true,
    basicVisible: false,
    closeVisible: false,

    positionV: '',
    animationV: true,
    basic: false,
    close: false,
  },

  TrialAddProject() {
    const newInput = {
      EstimatedTime: '',//预计完成时间
      ReasonExtension: '',//延期原因
      FinalTime: '',//最终完成时间
      TestResult: '',//检测结果
      SampleNumber: '',//样品编号
      Project: '',//检测项目
      Condition: '',//检测条件
      Engineer: '',//检测人员
      DisEngineer: '',//检测用时
      Quantity: '',//检测数量
      DeviceNumber: '',//设备编号
      StartTime: '',//开始时间
      EndTime: '',//结束时间
      TrialTime: '',//检测用时
      Sign: '',//复核签字
      ExtensionDate: '',//延期日期
    };
    this.setData({
      ...this.data.OrderInfo,
      OrderInfo: {
        ...this.data.OrderInfo,
        Items: [...this.data.OrderInfo.Items, newInput],
      }

    })
  },
  AddEstimatedTime(date, format, e) {
    this.setData({
      AddOrderItem: {
        ...this.data.AddOrderItem,
        EstimatedTime: date
      }
    })
  },
  AddReasonExtension(value) {
    this.setData({
      AddOrderItem: {
        ...this.data.AddOrderItem,
        ReasonExtension: value
      }
    })
  },
  AddFinalTime(date, format, e) {
    this.setData({
      AddOrderItem: {
        ...this.data.AddOrderItem,
        FinalTime: date
      }
    })
  },
  AddProject(value) {
    this.setData({
      AddOrderItem: {
        ...this.data.AddOrderItem,
        Project: value
      }
    })
  },
  AddCondition(value) {
    this.setData({
      AddOrderItem: {
        ...this.data.AddOrderItem,
        Condition: value
      }
    })
  },
  AddQuantity(value) {
    this.setData({
      AddOrderItem: {
        ...this.data.AddOrderItem,
        Quantity: value
      }
    })
  },
  AddSampleNumber(value) {
    this.setData({
      AddOrderItem: {
        ...this.data.AddOrderItem,
        SampleNumber: value
      }
    })
  },
  AddTestResult(value) {
    this.setData({
      AddOrderItem: {
        ...this.data.AddOrderItem,
        TestResult: value
      }
    })
  },
  AddDeviceNumber(value) {
    this.setData({
      AddOrderItem: {
        ...this.data.AddOrderItem,
        DeviceNumber: value
      }
    })
  },
  AddStartTime(date, format, e) {
    this.setData({
      AddOrderItem: {
        ...this.data.AddOrderItem,
        StartTime: date
      }
    })
  },
  AddEndTime(date, format, e) {
    this.setData({
      AddOrderItem: {
        ...this.data.AddOrderItem,
        EndTime: date,
        TrialTime: ((date - this.data.AddOrderItem.StartTime) / 1000 / 60 / 60 / 24).toFixed(2),
        ExtensionDate: ((date - this.data.AddOrderItem.FinalTime) / 1000 / 60 / 60 / 24).toFixed(2),
      }
    })
  },
  AddSign(value) {
    this.setData({
      AddOrderItem: {
        ...this.data.AddOrderItem,
        Sign: value
      }
    })
  },
  AddScoringFactor(value) {
    this.setData({
      AddOrderItem: {
        ...this.data.AddOrderItem,
        ScoringFactor: value
      }
    })
  },
  AddEntry() {
    console.log('提交数据', JSON.stringify(this.data.AddOrderItem));
    PostOrderAddItem(this.data.AddOrderItem.id,JSON.stringify(this.data.AddOrderItem),
      (res) => {
        my.alert({
          title: '提交成功',
        });
      },
      (err) => {
        my.alert({
          title: '提交成功1',
        });
      })

    
  },

  PopupClose() {
    this.setData({
      basic: false,
      scroll: false,
      close: false,
    });
  },
  ShowClose() {
    this.setData({ close: true });
  },
  ShowBasic(e) {
    var position = e.target.dataset.positionV;
    const id = e.target.dataset.id;
    let modifyOrderItem = {}
    GetOrder((RES)=>{
      console.log('RES',RES);
      RES.data.forEach(item => {
        item.item1.items.forEach(subItem => {
          if (subItem.id === id) {
            modifyOrderItem = subItem
          }
        })
      })
      this.setData({
        ModifyOrderItem: modifyOrderItem,
        positionV: position,
        basic: true,
      });
    })
    
  },
  ModifyEntry() {
    console.log('提交修改数据',JSON.stringify(this.data.ModifyOrderItem));
    PutOrderById(JSON.stringify(this.data.ModifyOrderItem), this.data.ModifyOrderItem.id, (res) => {
      my.alert({
        title: '提交成功',
      });
    })
  },
  ModifyFinalTime(date, format, e) {
    this.setData({
      ModifyOrderItem: {
        ...this.data.ModifyOrderItem,
        finalTime: date
      }
    })
  },
  ModifyReasonExtension(value) {
    this.setData({
      ModifyOrderItem: {
        ...this.data.ModifyOrderItem,
        reasonExtension: value
      }
    })
  },
  handlePopupClose() {
    this.setData({
      basicVisible: false,
      scrollVisible: false,
      closeVisible: false,
    });
  },
  handleShowClose() {
    this.setData({ closeVisible: true });
  },
  handleShowBasic(e) {
    var position = e.target.dataset.position;
    const id = e.target.dataset.id;
    this.setData({
      AddOrderItem: {
        ...this.data.AddOrderItem,
        id: id
      },
      position: position,
      basicVisible: true,
    });
    console.log('AddOrderItem1', this.data.AddOrderItem);
  },
  OnNumberingChange(value) {
    this.setData({
      OrderInfo: {
        ...this.data.OrderInfo,
        Numbering: value
      }
    })
  },
  OnWorkNumberChange(value) {
    this.setData({
      OrderInfo: {
        ...this.data.OrderInfo,
        WorkNumber: value
      }
    })
  },
  OnCustomerNameChange(value) {
    this.setData({
      OrderInfo: {
        ...this.data.OrderInfo,
        CustomerName: value
      }
    })
  },
  OnCommissioneEngineersChange(value) {
    this.setData({
      OrderInfo: {
        ...this.data.OrderInfo,
        CommissionEngineers: value
      }
    })
  },
  OnContactNumberChange(value) {
    this.setData({
      OrderInfo: {
        ...this.data.OrderInfo,
        ContactNumber: value
      }
    })
  },
  OnProductsNumberChange(value) {
    this.setData({
      OrderInfo: {
        ...this.data.OrderInfo,
        ProductsNumber: value
      }
    })
  },
  OnProductsNameChange(value) {
    this.setData({
      OrderInfo: {
        ...this.data.OrderInfo,
        ProductsName: value
      }
    })
  },
  OnCodeChange(value, e) {
    const id = e.target.dataset.id
    this.setData({
      OrderInfo: {
        ...this.data.OrderInfo,
        Code: this.data.OrderInfo.Code.map(i => {
          if (i.id === id) i.data = value
          return i
        }),
      }
    })
  },
  AddCodeNumber() {
    const id = Math.random()
    this.setData({
      OrderInfo: {
        ...this.data.OrderInfo,
        Code: [...this.data.OrderInfo.Code, {
          id,
          data: ''
        }],
      }

    })
  },
  OnProductsModelChange(value) {
    this.setData({
      OrderInfo: {
        ...this.data.OrderInfo,
        ProductsModel: value
      }
    })
  },
  OnProductsLotsChange(value) {
    this.setData({
      OrderInfo: {
        ...this.data.OrderInfo,
        ProductsLots: value
      }
    })
  },
  OnFormFactorChange(value) {
    this.setData({
      OrderInfo: {
        ...this.data.OrderInfo,
        FormFactor: value
      }
    })
  },
  OnTemperatureChange(value) {
    this.setData({
      OrderInfo: {
        ...this.data.OrderInfo,
        Temperature: value
      }
    })
  },
  OnHumidityChange(value) {
    this.setData({
      OrderInfo: {
        ...this.data.OrderInfo,
        Humidity: value
      }
    })
  },
  SceneChange(value) {
    this.setData({
      OrderInfo: {
        ...this.data.OrderInfo,
        Scene: value
      }
    })
  },
  UrgencyChange(value) {
    this.setData({
      OrderInfo: {
        ...this.data.OrderInfo,
        Urgency: value
      }
    })
  },
  OnFabricatedChange(value, e) {
    this.setData({
      OrderInfo: {
        ...this.data.OrderInfo,
        Fabricated: value
      }
    })
  },
  OnProjectChange(value, e) {
    const trials = this.data.OrderInfo.Items; // 获取当前的试验列表  
    // // 使用索引来更新Trial数组中的对应元素  
    trials[e.currentTarget.dataset.index].Project = value; // 索引从1开始，但数组索引从0开始，所以需要减1  
    this.setData({
      OrderInfo: {
        ...this.data.OrderInfo,
        Items: trials // 设置更新后的试验列表  
      }
    });
  },
  OnConditionChange(value, e) {
    const trials = this.data.OrderInfo.Items; // 获取当前的试验列表  
    // // 使用索引来更新Trial数组中的对应元素  
    trials[e.currentTarget.dataset.index].Condition = value; // 索引从1开始，但数组索引从0开始，所以需要减1  
    this.setData({
      OrderInfo: {
        ...this.data.OrderInfo,
        Items: trials // 设置更新后的试验列表  
      }
    });
  },
  OnEngineerChange(value, e) {
    const trials = this.data.OrderInfo.Items; // 获取当前的试验列表  
    // // 使用索引来更新Trial数组中的对应元素  
    trials[e.currentTarget.dataset.index].Engineer = value; // 索引从1开始，但数组索引从0开始，所以需要减1  
    this.setData({
      OrderInfo: {
        ...this.data.OrderInfo,
        Items: trials // 设置更新后的试验列表  
      }
    });
  },
  onEngineerAdd(e) {
    const trials = this.data.OrderInfo.Items; // 获取当前的试验列表 
    my.complexChoose({
      title: "选择人", //标题
      multiple: true, //是否多选
      maxUsers: 1000, //最大可选人数
      responseUserOnly: true, //返回人，或者返回人和部门
      success: (res) => {
        // console.log('res', res.users[0].userId)
        trials[e.currentTarget.dataset.index].Engineer = res.users[0].userId; // 索引从1开始，但数组索引从0开始，所以需要减1  
        trials[e.currentTarget.dataset.index].DisEngineer = res.users;
        this.setData({
          OrderInfo: {
            ...this.data.OrderInfo,
            Items: trials // 设置更新后的试验列表  
          }
        });
      }
    })
  },
  AddonEngineer(e) {
    my.complexChoose({
      title: "选择人", //标题
      multiple: true, //是否多选
      maxUsers: 1000, //最大可选人数
      responseUserOnly: true, //返回人，或者返回人和部门
      success: (res) => {
        console.log('res1111', res)
        this.setData({
          AddOrderItem: {
            ...this.data.AddOrderItem,
            Engineer: res.users[0].userId,
            DisEngineer:res.users[0].name
          }
        })
        console.log('dddd',this.data.AddOrderItem);
      }
    })
  },
  OnQuantityChange(value, e) {
    const trials = this.data.OrderInfo.Items; // 获取当前的试验列表  
    // // 使用索引来更新Trial数组中的对应元素  
    trials[e.currentTarget.dataset.index].Quantity = value; // 索引从1开始，但数组索引从0开始，所以需要减1  
    this.setData({
      OrderInfo: {
        ...this.data.OrderInfo,
        Items: trials // 设置更新后的试验列表  
      }
    });
  },
  OnDeviceNumberChange(value, e) {
    const trials = this.data.OrderInfo.Items; // 获取当前的试验列表  
    // // 使用索引来更新Trial数组中的对应元素  
    trials[e.currentTarget.dataset.index].DeviceNumber = value; // 索引从1开始，但数组索引从0开始，所以需要减1  
    this.setData({
      OrderInfo: {
        ...this.data.OrderInfo,
        Items: trials // 设置更新后的试验列表  
      }
    });
  },
  OnSignChange(value, e) {
    const trials = this.data.OrderInfo.Items; // 获取当前的试验列表  
    // // 使用索引来更新Trial数组中的对应元素  
    trials[e.currentTarget.dataset.index].Sign = value; // 索引从1开始，但数组索引从0开始，所以需要减1  
    this.setData({
      OrderInfo: {
        ...this.data.OrderInfo,
        Items: trials // 设置更新后的试验列表  
      }
    });
  },
  OnScoringFactorChange(value, e) {
    const trials = this.data.OrderInfo.Items; // 获取当前的试验列表  
    // // 使用索引来更新Trial数组中的对应元素  
    trials[e.currentTarget.dataset.index].ScoringFactor = value; // 索引从1开始，但数组索引从0开始，所以需要减1  
    this.setData({
      OrderInfo: {
        ...this.data.OrderInfo,
        Items: trials // 设置更新后的试验列表  
      }
    });
  },
  EstimatedTime(date, format, e) {
    const trials = this.data.OrderInfo.Items; // 获取当前的试验列表  
    // // 使用索引来更新Trial数组中的对应元素  
    trials[e.currentTarget.dataset.index].EstimatedTime = date; // 索引从1开始，但数组索引从0开始，所以需要减1  
    this.setData({
      OrderInfo: {
        ...this.data.OrderInfo,
        Items: trials // 设置更新后的试验列表  
      }
    });
  },
  OnReasonExtensionChange(value, e) {
    const trials = this.data.OrderInfo.Items; // 获取当前的试验列表  
    // // 使用索引来更新Trial数组中的对应元素  
    trials[e.currentTarget.dataset.index].ReasonExtension = value; // 索引从1开始，但数组索引从0开始，所以需要减1  
    this.setData({
      OrderInfo: {
        ...this.data.OrderInfo,
        Items: trials // 设置更新后的试验列表  
      }
    });
  },
  FinalTime(date, format, e) {
    const trials = this.data.OrderInfo.Items; // 获取当前的试验列表  
    // // 使用索引来更新Trial数组中的对应元素  
    trials[e.currentTarget.dataset.index].FinalTime = date; // 索引从1开始，但数组索引从0开始，所以需要减1  
    this.setData({
      OrderInfo: {
        ...this.data.OrderInfo,
        Items: trials // 设置更新后的试验列表  
      }
    });
  },

  OnSampleNumberChange(value, e) {
    const trials = this.data.OrderInfo.Items; // 获取当前的试验列表  
    // // 使用索引来更新Trial数组中的对应元素  
    trials[e.currentTarget.dataset.index].SampleNumber = value; // 索引从1开始，但数组索引从0开始，所以需要减1  
    this.setData({
      OrderInfo: {
        ...this.data.OrderInfo,
        Items: trials // 设置更新后的试验列表  
      }
    });
  },
  OnTestResultChange(value, e) {
    const trials = this.data.OrderInfo.Items; // 获取当前的试验列表  
    // // 使用索引来更新Trial数组中的对应元素  
    trials[e.currentTarget.dataset.index].TestResult = value; // 索引从1开始，但数组索引从0开始，所以需要减1  
    this.setData({
      OrderInfo: {
        ...this.data.OrderInfo,
        Items: trials // 设置更新后的试验列表  
      }
    });
  },

  StartTimeOk(date, format, e) {
    const trials = this.data.OrderInfo.Items; // 获取当前的试验列表  
    // // 使用索引来更新Trial数组中的对应元素  
    trials[e.currentTarget.dataset.index].StartTime = date; // 索引从1开始，但数组索引从0开始，所以需要减1  
    this.setData({
      OrderInfo: {
        ...this.data.OrderInfo,
        Items: trials // 设置更新后的试验列表  
      }
    });
  },
  EndTimeOk(date, format, e) {
    const trials = this.data.OrderInfo.Items; // 获取当前的试验列表  
    // // 使用索引来更新Trial数组中的对应元素  
    trials[e.currentTarget.dataset.index].EndTime = date; // 索引从1开始，但数组索引从0开始，所以需要减1  
    trials[e.currentTarget.dataset.index].TrialTime = ((trials[e.currentTarget.dataset.index].EndTime - trials[e.currentTarget.dataset.index].StartTime) / 1000 / 60 / 60 / 24).toFixed(2)
    trials[e.currentTarget.dataset.index].ExtensionDate = ((trials[e.currentTarget.dataset.index].EndTime - trials[e.currentTarget.dataset.index].FinalTime) / 1000 / 60 / 60 / 24).toFixed(2)
    this.setData({
      OrderInfo: {
        ...this.data.OrderInfo,
        Items: trials // 设置更新后的试验列表  
      }
    });
  },
  ExtensionDateOk(date, format, e) {
    const trials = this.data.OrderInfo.Items; // 获取当前的试验列表  
    // // 使用索引来更新Trial数组中的对应元素  
    trials[e.currentTarget.dataset.index].ExtensionDate = date; // 索引从1开始，但数组索引从0开始，所以需要减1  
    this.setData({
      OrderInfo: {
        ...this.data.OrderInfo,
        Items: trials // 设置更新后的试验列表  
      }
    });
  },
  FinishTimeOk(date, format, e) {
    this.setData({
      OrderInfo: {
        ...this.data.OrderInfo,
        CompletionTime: date
      },
    })
  },
  ProposedDate(date, format, e) {
    this.setData({
      OrderInfo: {
        ...this.data.OrderInfo,
        ProposedDate: date
      }
    })
  },
  ReviewDate(date, format, e) {
    this.setData({
      OrderInfo: {
        ...this.data.OrderInfo,
        ReviewDate: date
      }
    })
  },
  EstimatedTimeOk(date, format, e) {
    this.setData({
      OrderInfo: {
        ...this.data.OrderInfo,
        EstimatedTime: date
      }
    })
  },
  Delete(e) {
    const id = e.currentTarget.dataset.id
    OrderDeleteData(id, (res) => {
      my.alert({
        title: '撤销成功',
      });
      //刷新数据
      this.setData({
        ReceiveData: this.data.ReceiveData.filter((it) => {
          return it.item1.id !== id
        })
      })
    }, (err) => {
      my.alert({
        title: '撤销失败',
      });
    })
  },
  ReturnDocx(e) {
    const id = e.currentTarget.dataset.id
    GetReturnDocx(id, (res) => {
      console.log('文件下载成功');
    });
  },
  // 上传数据
  onSubmit(e) {
    const orderInfoWithDataOnly = {
      ...this.data.OrderInfo, // 复制OrderInfo对象的所有其他属性  
      Code: this.data.OrderInfo.Code.map(item => item.data) // 只提取Code数组中每个对象的data属性  
    };
    console.log('orderInfoWithDataOnly', JSON.stringify(orderInfoWithDataOnly));
    PostOrder(JSON.stringify(orderInfoWithDataOnly),
      (res) => {
        my.alert({
          title: '提交成功',
        });
        my.getStorage({
          key: 'userInfo',
          success: (storage) => {
            GetOrder((res) => {
              // console.log('res', res);
              // 过滤并处理订单数据  
              const filteredAndProcessedOrders = res.data
                //筛选未完成的订单
                .filter(order => (order.item1.completeOrderId === '0' && !order.item1.startApprove))
                .map(order => {
                  // 遍历每个订单的items数组，并获取工程师的名字  
                  const processedItems = order.item1.items.map(item => {
                    if (item.engineer) {
                      return new Promise((resolve) => {
                        GetUserInfo({
                          userId: item.engineer,
                          fileds: null // 确保这是正确的字段名  
                        }, (userInfo) => {
                          const engineerName = GetUserInfoFiled(userInfo, 'name'); // 确保这是正确的函数名  
                          const newItem = {
                            ...item,
                            engineer: engineerName
                          };
                          resolve(newItem);
                        });
                      });
                    } else {
                      // 如果 item.engineer 为空，则直接返回原始item  
                      return Promise.resolve(item);
                    }
                  });
                  // 等待所有items的Promise解决，然后返回新的订单对象（包含处理过的items）  
                  return Promise.all(processedItems).then(newItems => ({
                    ...order,
                    items: newItems
                  }));
                });
              // 等待所有订单的Promise解决，然后渲染值到前端  
              Promise.all(filteredAndProcessedOrders)
                .then(updatedOrders => {
                  this.setData({
                    OrderInfo: {
                      ...this.data.OrderInfo,
                      CorpId: storage.data.result.userid
                    },
                    ReceiveData: updatedOrders.reverse(), // 反转数组 
                    FinshData: res.data.reverse()
                  });
                  console.log('ReceiveData', this.data.ReceiveData);
                  // console.log('FinshData', this.data.FinshData);
                })
                .catch(error => {
                  console.error('Error fetching user info:', error);
                  // 处理错误情况  
                });
            });
          }
        })
        //清除填写数据
        this.setData({
          OrderInfo: {
            ...this.data.OrderInfo,
            Numbering: '', //编号
            WorkNumber: '', //随工单号
            CustomerName: '', //客户名称
            CommissionEngineers: '', //委托工程师
            ContactNumber: '', //联系电话
            ProductsNumber: '', //产品数量
            ProductsName: '', //产品名称
            ProductsModel: '', //产品型号
            ProductsLots: '', //产品批次
            FormFactor: '', //封装形式
            Scene: '是', //现场
            Urgency: '正常', //紧急程度
            CompletionTime: new Date(), //完成时间
            EstimatedTime: new Date(),//预计最终完成时间
            Temperature: '', //温度
            Humidity: '', //湿度
            Items: [{
              EstimatedTime: new Date(),//预计完成时间
              ReasonExtension: '',//延期原因
              FinalTime: new Date(),//最终完成时间
              TestResult: '',//检测结果
              SampleNumber: '',//样品编号
              Project: '',//检测项目
              Condition: '',//检测条件
              Engineer: '',//检测人员
              DisEngineer: '',//检测用时
              Quantity: '',//检测数量
              DeviceNumber: '',//设备编号
              StartTime: new Date(),//开始时间
              EndTime: new Date(),//结束时间
              TrialTime: '',//检测用时
              Sign: '',//复核签字
              ScoringFactor: '',//评分因子
              ExtensionDate: '',//延期日期
            }], //试验
            Laboratory: '是', //是否留着实验室
            Fabricated: '', //拟制
            Review: '', //复核
            ProposedDate: new Date(),
            ReviewDate: new Date(),
            Code: [], //样品编号
          },
        })
      },
      (err) => {
        my.alert({
          title: '提交成功1',
        });
      })
  },
  //获取数据
  onLoad() {
    my.getStorage({
      key: 'userInfo',
      success: (storage) => {
        GetOrder((res) => {
          // console.log('res', res);
          // 过滤并处理订单数据  
          const filteredAndProcessedOrders = res.data
            //筛选未完成的订单
            .filter(order => (order.item1.completeOrderId === '0' && !order.item1.startApprove))
            .map(order => {
              // 遍历每个订单的items数组，并获取工程师的名字  
              const processedItems = order.item1.items.map(item => {
                if (item.engineer) {
                  return new Promise((resolve) => {
                    GetUserInfo({
                      userId: item.engineer,
                      fileds: null // 确保这是正确的字段名  
                    }, (userInfo) => {
                      const engineerName = GetUserInfoFiled(userInfo, 'name'); // 确保这是正确的函数名  
                      const newItem = {
                        ...item,
                        engineer: engineerName
                      };
                      resolve(newItem);
                    });
                  });
                } else {
                  // 如果 item.engineer 为空，则直接返回原始item  
                  return Promise.resolve(item);
                }
              });
              // 等待所有items的Promise解决，然后返回新的订单对象（包含处理过的items）  
              return Promise.all(processedItems).then(newItems => ({
                ...order,
                items: newItems
              }));
            });
          // 等待所有订单的Promise解决，然后渲染值到前端  
          Promise.all(filteredAndProcessedOrders)
            .then(updatedOrders => {
              this.setData({
                OrderInfo: {
                  ...this.data.OrderInfo,
                  CorpId: storage.data.result.userid
                },
                ReceiveData: updatedOrders.reverse(), // 反转数组 
                FinshData: res.data.reverse()
              });
              console.log('ReceiveData', this.data.ReceiveData);
              // console.log('FinshData', this.data.FinshData);
            })
            .catch(error => {
              console.error('Error fetching user info:', error);
              // 处理错误情况  
            });
        });
      }
    })
  },
  // 选择操作人
  Operators() {
    my.complexChoose({
      title: "测试标题", //标题
      multiple: true, //是否多选
      limitTips: "超出了", //超过限定人数返回提示
      maxUsers: 1000, //最大可选人数
      responseUserOnly: true, //返回人，或者返回人和部门
      success: (res) => {
        // console.log('res', res);
        this.setData({
          OrderInfo: {
            ...this.data.OrderInfo,
            EquipmentInvolved: [],
          }
        })
        for (let index = 0; index < res.users.length; index++) {
          this.setData({
            OrderInfo: {
              ...this.data.OrderInfo,
              EquipmentInvolved: [...this.data.OrderInfo.EquipmentInvolved, res.users[index]],
            }
          })
        }
      },
      fail: function (err) { }
    })
  },
  Del(e) {
    const n = e.target.dataset.name
    this.setData({
      OrderInfo: {
        EquipmentInvolved: this.data.OrderInfo.EquipmentInvolved.filter((name) => {
          return name !== n
        })
      }
    })
  },
  PickerhandleOk(value, column, e) {
    const name = e.currentTarget.dataset.name
    const Temp = []
    this.data.OrderInfo.EquipmentInvolved.forEach((it) => {
      if (it.name === name) {
        Temp.push({
          ...it,
          Equipment: value
        })
      } else
        Temp.push({
          ...it
        })
    })
    this.setData({
      OrderInfo: {
        ...this.data.OrderInfo,
        EquipmentInvolved: Temp
      }
    })
  },
});